class BitUtils {
  /// 获取整数的第 index 位
  ///
  /// [number] 是原始整数。
  /// [position] 是位的索引（从右向左，从 0 开始计数）。
  /// 返回第 index 位的值（0 或 1）。
  static int getBit(int number, int position) {
    if (position < 0 || position > 31) {
      throw ArgumentError('Position must be between 0 and 31');
    }

    // 确保32位无符号
    number = number & 0xFFFFFFFF;

    return (number >> position) & 1;
  }

  /// 获取整数的 position 位
  ///
  /// [number] 是原始整数。
  /// [position] 开始的位索引。0 开始
  /// [len] 要获取的位数。
  static int getBits(int number, int position, int len) {
    // 参数验证
    if (position < 0) {
      throw ArgumentError('Position must be non-negative: $position');
    }
    if (len < 0) {
      throw ArgumentError('Length must be non-negative: $len');
    }

    if (len == 0) return 0;

    // 动态检测整数位宽
    const int bitWidth = 64; // Dart int 在大多数平台是64位

    if (position >= bitWidth) {
      return 0; // 位置超出位宽，返回0而不是抛出异常
    }

    // 计算实际要获取的位数
    final int actualLen =
        (position + len > bitWidth) ? (bitWidth - position) : len;

    // 生成掩码
    final int mask = (actualLen == bitWidth) ? -1 : ((1 << actualLen) - 1);

    return (number >> position) & mask;
  }

  /// 设置整数的 index 位
  ///
  /// [value] 是原始整数。
  /// [startPosition] 开始的位索引。0 开始
  /// [endPosition] 结束的位索引。
  /// [newValue] 需要设置的值
  static int setBits(
      int value, int startPosition, int endPosition, int newValue) {
    // 参数验证
    if (startPosition < 0 || endPosition < startPosition || endPosition > 31) {
      throw ArgumentError(
          'Invalid bit range: start=$startPosition, end=$endPosition');
    }

    int bitCount = endPosition - startPosition + 1;
    int maxValue = (1 << bitCount) - 1;

    if (newValue < 0 || newValue > maxValue) {
      throw ArgumentError(
          'newValue $newValue exceeds $bitCount-bit range (0-$maxValue)');
    }

    // 使用更清晰的步骤
    value = value & 0xFFFFFFFF;

    // 直接计算（推荐）
    int clearMask = ~(maxValue << startPosition);
    value &= clearMask; // 清除目标位
    value |= (newValue << startPosition); // 设置新值

    return value;
  }

  // 检查指定位是否为 1
  static bool isBitOne(int number, int position) =>
      getBit(number, position) == 1;

  /// 将整数的第 index 位设置为 0 或 1, index 从0开始
  ///
  /// [targetValue] 是原始整数。
  /// [setToOne] 为 true 时，将第 index 位设置为 1；为 false 时，将第 7 位设置为 0。
  static int getNewBit(int targetValue, int index, bool setToOne) {
    if (setToOne) {
      // 将指定位设置为 1：使用按位或操作
      return targetValue | (1 << index); // 注意：index 是位的索引（从 0 开始）
    } else {
      // 将指定位设置为 0：使用按位与操作和取反
      return targetValue & ~(1 << index);
    }
  }

  // 设置指定位的值
  static int setBit(int index, bool setToOne) => setToOne ? 1 << index : 0;

  /// 获取整数的低 index 位
  ///
  /// [value] 是原始整数。
  /// [n] 是要提取的低位数，范围是 1~8。
  static int getLowBits(int value, int n) {
    if (n < 0 || n > 63) {
      throw ArgumentError('Index must be between 0 and 63');
    }
    return value & ((1 << n) - 1);
  }

  /// 获取某个字节的高 n 位的值
  ///
  /// [byte] 是目标字节，范围是 0~255。
  /// [n] 是要提取的高位数，范围是 1~8。
  static int getHighBits(int byte, int n) {
    if (n < 1 || n > 8) {
      throw ArgumentError('n 必须介于 1 和 8 之间');
    }
    if (byte < 0 || byte > 255) {
      throw ArgumentError('byte 必须介于 0 和 255 之间');
    }

    // 右移 (8 - n) 位，将高 n 位移到最低位
    return byte >> (8 - n);
  }
}
